package com.baigt.j8.stream;

import net.sf.json.JSONArray;
import net.sf.json.JSONObject;

import java.util.Arrays;
import java.util.List;
import java.util.stream.Stream;

/**
 * Stream学习
 * java.util.stream.Stream
 * 从文档注释中得出如下几个流的构成特点：
 *  源.中间操作.终端操作
 *      源：
 *          might be an array, a collection, a generator function, an I/O channel,
 *          可以是集合Collect、数组Array、生成的函数、io通道
 *      中间操作：
 *          >intermediate operations</em> (which transform a stream into another stream, such as {@link Stream#filter(Predicate)})
 *          比如filter这种中间操作，转换为其他流对象
 *      终端操作：
 *          terminal operation</em> (which produces a result or side-effect, such as {@link Stream#count()} or {@link Stream#forEach(Consumer)})
 *          比如 count、foreach这种操作是终端操作，会返回一个结果出来(void 或者其他)
 * 特性：
 *      流具有lazy的特点(notImmediatelyRunOfStream)
 *      中间操作不是立刻执行的，在调用terminal 类型的操作时才会执行
 *      除了io流之外，其他流的资源基础不需要手动的显式close管理
 * <p>
 *      流一般只能被使用一次(useSingleOfStream)
 */
public class StreamDemo {
    public static void main(String[] args) {
        Stream<String> stream1 = Stream.of("Hello", "Ricky");
        List<String> list = Arrays.asList("Hello", "Ricky");
        System.out.println(".......");
        notImmediatelyRunOfStream(list);
        System.out.println(".......");
        execProcessOfStream(list);

    }

    public static void notImmediatelyRunOfStream(List<String> list) {
        // 中间操作不是立刻执行
        Stream<String> singleUse = list.stream();
        singleUse.filter(s -> {
            System.out.println("执行判断");
            return s.equals("Hello");
        });
    }

    public static void useSingleOfStream(List<String> list) {
        try {
            // 流只能使用一次
            Stream<String> singleUse = list.stream();
            singleUse.filter(s -> {
                return s.equals("Hello");
            });
            singleUse.filter(s -> {
                return s.equals("Ricky");
            });
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public static void execProcessOfStream(List<String> list) {
        // 执行过程特点
        Stream<String> singleUse = list.stream();
        singleUse.filter(s -> {
            System.out.println("1. 执行判断");
            return true;
        }).filter(s -> {
            System.out.println("2. 执行判断");
            return true;
        }).forEach(s->{
            System.out.println(s);
        });
    }
    public static void collectOfStream(List<String> list) {
        //        list.stream().collect(Collectors.toList());
//        list.stream().collect(LinkedList::new, LinkedList::add, LinkedList::addAll).forEach(System.out::println);
        System.out.println(list.stream().collect(JSONArray::new, JSONArray::add, JSONArray::addAll).toString());
        System.out.println(list.stream().collect(JSONObject::new, (json, item) -> {
            json.put(item, item);
        }, JSONObject::putAll).toString());
    }
}
